<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html>
        <head>
          <title>prolog.LogicEngine</title>
          <meta http-equiv="content-type" content="text/html; charset=UTF-8" />
          
      <link type="text/css" media="screen" rel="stylesheet" href="../lib/template.css" />
      <script type="text/javascript" src="../lib/jquery.js"></script>
      <script type="text/javascript" src="../lib/jquery-ui.js"></script>
      <script type="text/javascript" src="../lib/template.js"></script>
      <script type="text/javascript" src="../lib/tools.tooltip.js"></script>
    
        </head>
        <body onload="sh_highlightDocument('../lib/', '.min.js');" class="type">
      <div id="definition">
        <img src="../lib/class_big.png" />
        <p id="owner"><a name="prolog" class="extype" href="package.html">prolog</a></p>
        <h1>LogicEngine</h1>
      </div>

      <h4 class="signature" id="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">class</span>
      </span>
      <span class="symbol">
        <span class="name">LogicEngine</span><span class="result"> extends <a name="prolog.interp.Prog" class="extype" href="interp/Prog.html">Prog</a></span>
      </span>
      </h4>
      
      <div class="fullcommenttop" id="comment"><div class="toggleContainer block">
          <span class="toggle">Linear Supertypes</span>
          <div class="superTypes hiddenContent"><a name="prolog.interp.Prog" class="extype" href="interp/Prog.html">Prog</a>, <a name="prolog.terms.TermSource" class="extype" href="terms/TermSource.html">TermSource</a>, <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>], <span name="scala.collection.TraversableOnce" class="extype">TraversableOnce</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>], <span name="scala.collection.GenTraversableOnce" class="extype">GenTraversableOnce</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>], <a name="prolog.terms.Fluent" class="extype" href="terms/Fluent.html">Fluent</a>, <a name="prolog.terms.SystemObject" class="extype" href="terms/SystemObject.html">SystemObject</a>, <a name="prolog.terms.Nonvar" class="extype" href="terms/Nonvar.html">Nonvar</a>, <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>, <span name="java.lang.Cloneable" class="extype">Cloneable</span>, AnyRef, <span name="scala.Any" class="extype">Any</span></div>
        </div></div>
    

      <div id="mbrsel">
        <div id="textfilter"><span class="pre"></span><span class="input"><input accesskey="/" type="text" /></span><span class="post"></span></div>
        <div id="order">
              <span class="filtertype">Ordering</span>
              <ol><li class="alpha in"><span>Alphabetic</span></li><li class="inherit out"><span>By inheritance</span></li></ol>
            </div>
        <div id="ancestors">
              <span class="filtertype">Inherited</span>
              <ol><li class="hideall out"><span>Hide All</span></li>
              <li class="showall in"><span>Show all</span></li></ol>
              <ol id="linearization"><li name="prolog.LogicEngine" class="in"><span>LogicEngine</span></li><li name="prolog.interp.Prog" class="in"><span>Prog</span></li><li name="prolog.terms.TermSource" class="in"><span>TermSource</span></li><li name="scala.collection.Iterator" class="in"><span>Iterator</span></li><li name="scala.collection.TraversableOnce" class="in"><span>TraversableOnce</span></li><li name="scala.collection.GenTraversableOnce" class="in"><span>GenTraversableOnce</span></li><li name="prolog.terms.Fluent" class="in"><span>Fluent</span></li><li name="prolog.terms.SystemObject" class="in"><span>SystemObject</span></li><li name="prolog.terms.Nonvar" class="in"><span>Nonvar</span></li><li name="prolog.terms.Term" class="in"><span>Term</span></li><li name="java.lang.Cloneable" class="in"><span>Cloneable</span></li><li name="scala.AnyRef" class="in"><span>AnyRef</span></li><li name="scala.Any" class="in"><span>Any</span></li></ol>
            </div>
        <div id="visbl">
            <span class="filtertype">Visibility</span>
            <ol><li class="public in"><span>Public</span></li><li class="all out"><span>All</span></li></ol>
          </div>
      </div>

      <div id="template">
        <div id="allMembers">
        <div class="members" id="constructors">
              <h3>Instance Constructors</h3>
              <ol><li visbl="pub" name="prolog.LogicEngine#this" data-isabs="false">
      <a id="this:LogicEngine"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">new</span>
      </span>
      <span class="symbol">
        <span class="name">LogicEngine</span><span class="params">(<span name="fname">fname: String</span>)</span>
      </span>
      </h4>
      
    </li><li visbl="pub" name="prolog.LogicEngine#this" data-isabs="false">
      <a id="this:LogicEngine"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">new</span>
      </span>
      <span class="symbol">
        <span class="name">LogicEngine</span><span class="params">()</span>
      </span>
      </h4>
      
    </li><li visbl="pub" name="prolog.LogicEngine#this" data-isabs="false">
      <a id="this:LogicEngine"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">new</span>
      </span>
      <span class="symbol">
        <span class="name">LogicEngine</span><span class="params">(<span name="db">db: <a name="prolog.fluents.DataBase" class="extype" href="fluents/DataBase.html">DataBase</a></span>)</span>
      </span>
      </h4>
      
    </li></ol>
            </div>

        <div class="types members" id="types">
              <h3>Type Members</h3>
              <ol><li visbl="pub" name="prolog.interp.Prog#CLAUSE" data-isabs="false">
      <a id="CLAUSE:CLAUSE"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">type</span>
      </span>
      <span class="symbol">
        <span class="name">CLAUSE</span><span class="result"> = <span name="scala.collection.immutable.List" class="extype">List</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.interp.Prog" class="extype" href="interp/Prog.html">Prog</a></dd></dl></div>
    </li><li visbl="pub" name="prolog.interp.Prog#GOAL" data-isabs="false">
      <a id="GOAL:GOAL"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">type</span>
      </span>
      <span class="symbol">
        <span class="name">GOAL</span><span class="result"> = <span name="scala.collection.immutable.List" class="extype">List</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.interp.Prog" class="extype" href="interp/Prog.html">Prog</a></dd></dl></div>
    </li></ol>
            </div>

        

        <div class="values members" id="values">
              <h3>Value Members</h3>
              <ol><li visbl="pub" name="scala.AnyRef#!=" data-isabs="false">
      <a id="!=(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $bang$eq">!=</span><span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.Any#!=" data-isabs="false">
      <a id="!=(Any):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $bang$eq">!=</span><span class="params">(<span name="arg0">arg0: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef###" data-isabs="false">
      <a id="##():Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $hash$hash">##</span><span class="params">()</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#++" data-isabs="false">
      <a id="++[B&gt;:Term](⇒ GenTraversableOnce[B]):Iterator[B]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $plus$plus">++</span><span class="tparams">[<span name="B">B &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="params">(<span name="that">that: ⇒ <span name="scala.collection.GenTraversableOnce" class="extype">GenTraversableOnce</span>[B]</span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#/:" data-isabs="false">
      <a id="/:[B](B)((B, Term) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $div$colon">/:</span><span class="tparams">[<span name="B">B</span>]</span><span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="op">op: (B, <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenTraversableOnce#/:\" data-isabs="false">
      <a id="/:\[A1&gt;:Term](A1)((A1, A1) ⇒ A1):A1"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $div$colon$bslash">/:\</span><span class="tparams">[<span name="A1">A1 &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="params">(<span name="z">z: A1</span>)</span><span class="params">(<span name="op">op: (A1, A1) ⇒ A1</span>)</span><span class="result">: A1</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#:\" data-isabs="false">
      <a id=":\[B](B)((Term, B) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $colon$bslash">:\</span><span class="tparams">[<span name="B">B</span>]</span><span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="op">op: (<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>, B) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#==" data-isabs="false">
      <a id="==(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $eq$eq">==</span><span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.Any#==" data-isabs="false">
      <a id="==(Any):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $eq$eq">==</span><span class="params">(<span name="arg0">arg0: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#addString" data-isabs="false">
      <a id="addString(StringBuilder):StringBuilder"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">addString</span><span class="params">(<span name="b">b: StringBuilder</span>)</span><span class="result">: StringBuilder</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#addString" data-isabs="false">
      <a id="addString(StringBuilder,String):StringBuilder"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">addString</span><span class="params">(<span name="b">b: StringBuilder</span>, <span name="sep">sep: String</span>)</span><span class="result">: StringBuilder</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#addString" data-isabs="false">
      <a id="addString(StringBuilder,String,String,String):StringBuilder"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">addString</span><span class="params">(<span name="b">b: StringBuilder</span>, <span name="start">start: String</span>, <span name="sep">sep: String</span>, <span name="end">end: String</span>)</span><span class="result">: StringBuilder</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#aggregate" data-isabs="false">
      <a id="aggregate[B](B)((B, Term) ⇒ B,(B, B) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">aggregate</span><span class="tparams">[<span name="B">B</span>]</span><span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="seqop">seqop: (B, <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>) ⇒ B</span>, <span name="combop">combop: (B, B) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.Any#asInstanceOf" data-isabs="false">
      <a id="asInstanceOf[T0]:T0"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">asInstanceOf</span><span class="tparams">[<span name="T0">T0</span>]</span><span class="result">: T0</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li visbl="pub" name="prolog.LogicEngine#askAnswer" data-isabs="false">
      <a id="askAnswer():Term"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">askAnswer</span><span class="params">()</span><span class="result">: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>
      </span>
      </h4>
      
    </li><li visbl="pub" name="prolog.terms.Nonvar#bind_to" data-isabs="false">
      <a id="bind_to(Term,Trail):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">bind_to</span><span class="params">(<span name="that">that: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>, <span name="trail">trail: <a name="prolog.terms.Trail" class="extype" href="terms/Trail.html">Trail</a></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.terms.Nonvar" class="extype" href="terms/Nonvar.html">Nonvar</a> → <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#buffered" data-isabs="false">
      <a id="buffered:BufferedIterator[Term]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">buffered</span><span class="result">: <span name="scala.collection.BufferedIterator" class="extype">BufferedIterator</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="prt" name="scala.AnyRef#clone" data-isabs="false">
      <a id="clone():AnyRef"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">clone</span><span class="params">()</span><span class="result">: AnyRef</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[<a name="java.lang" class="extype" href="../java/lang/package.html">lang</a>] </dd><dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#collect" data-isabs="false">
      <a id="collect[B](PartialFunction[Term, B]):Iterator[B]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">collect</span><span class="tparams">[<span name="B">B</span>]</span><span class="params">(<span name="pf">pf: <span name="scala.PartialFunction" class="extype">PartialFunction</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>, B]</span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd><dt>Annotations</dt><dd>
                <span class="name">@migration</span>
              
        </dd><dt>Migration</dt><dd class="cmt"><p><i>(Changed in version 2.8.0)</i> <code>collect</code> has changed. The previous behavior can be reproduced with <code>toSeq</code>.</p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#collectFirst" data-isabs="false">
      <a id="collectFirst[B](PartialFunction[Term, B]):Option[B]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">collectFirst</span><span class="tparams">[<span name="B">B</span>]</span><span class="params">(<span name="pf">pf: <span name="scala.PartialFunction" class="extype">PartialFunction</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>, B]</span>)</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#contains" data-isabs="false">
      <a id="contains(Any):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">contains</span><span class="params">(<span name="elem">elem: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="pub" name="prolog.interp.Prog#copier" data-isabs="false">
      <a id="copier:Copier"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">val</span>
      </span>
      <span class="symbol">
        <span class="name">copier</span><span class="result">: <a name="prolog.terms.Copier" class="extype" href="terms/Copier.html">Copier</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.interp.Prog" class="extype" href="interp/Prog.html">Prog</a></dd></dl></div>
    </li><li visbl="pub" name="prolog.terms.Term#copy" data-isabs="false">
      <a id="copy:Term"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">copy</span><span class="result">: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#copyToArray" data-isabs="false">
      <a id="copyToArray[B&gt;:Term](Array[B],Int,Int):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">copyToArray</span><span class="tparams">[<span name="B">B &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="params">(<span name="xs">xs: <span name="scala.Array" class="extype">Array</span>[B]</span>, <span name="start">start: <span name="scala.Int" class="extype">Int</span></span>, <span name="len">len: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#copyToArray" data-isabs="false">
      <a id="copyToArray[B&gt;:Term](Array[B]):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">copyToArray</span><span class="tparams">[<span name="B">B &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="params">(<span name="xs">xs: <span name="scala.Array" class="extype">Array</span>[B]</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#copyToArray" data-isabs="false">
      <a id="copyToArray[B&gt;:Term](Array[B],Int):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">copyToArray</span><span class="tparams">[<span name="B">B &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="params">(<span name="xs">xs: <span name="scala.Array" class="extype">Array</span>[B]</span>, <span name="start">start: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#copyToBuffer" data-isabs="false">
      <a id="copyToBuffer[B&gt;:Term](Buffer[B]):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">copyToBuffer</span><span class="tparams">[<span name="B">B &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="params">(<span name="dest">dest: <span name="scala.collection.mutable.Buffer" class="extype">Buffer</span>[B]</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#count" data-isabs="false">
      <a id="count((Term) ⇒ Boolean):Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">count</span><span class="params">(<span name="p">p: (<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#drop" data-isabs="false">
      <a id="drop(Int):Iterator[Term]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">drop</span><span class="params">(<span name="n">n: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#dropWhile" data-isabs="false">
      <a id="dropWhile((Term) ⇒ Boolean):Iterator[Term]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">dropWhile</span><span class="params">(<span name="p">p: (<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#duplicate" data-isabs="false">
      <a id="duplicate:(Iterator[Term], Iterator[Term])"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">duplicate</span><span class="result">: (<span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>], <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>])</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#eq" data-isabs="false">
      <a id="eq(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">eq</span><span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#equals" data-isabs="false">
      <a id="equals(Any):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">equals</span><span class="params">(<span name="arg0">arg0: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="prolog.terms.Term#exec" data-isabs="false">
      <a id="exec(Prog):Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">exec</span><span class="params">(<span name="p">p: <a name="prolog.interp.Prog" class="extype" href="interp/Prog.html">Prog</a></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></dd></dl></div>
    </li><li visbl="pub" name="prolog.terms.Term#exec" data-isabs="false">
      <a id="exec():Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">exec</span><span class="params">()</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#exists" data-isabs="false">
      <a id="exists((Term) ⇒ Boolean):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">exists</span><span class="params">(<span name="p">p: (<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#filter" data-isabs="false">
      <a id="filter((Term) ⇒ Boolean):Iterator[Term]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">filter</span><span class="params">(<span name="p">p: (<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#filterNot" data-isabs="false">
      <a id="filterNot((Term) ⇒ Boolean):Iterator[Term]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">filterNot</span><span class="params">(<span name="p">p: (<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="prt" name="scala.AnyRef#finalize" data-isabs="false">
      <a id="finalize():Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">finalize</span><span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[<a name="java.lang" class="extype" href="../java/lang/package.html">lang</a>] </dd><dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#find" data-isabs="false">
      <a id="find((Term) ⇒ Boolean):Option[Term]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">find</span><span class="params">(<span name="p">p: (<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#flatMap" data-isabs="false">
      <a id="flatMap[B]((Term) ⇒ GenTraversableOnce[B]):Iterator[B]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">flatMap</span><span class="tparams">[<span name="B">B</span>]</span><span class="params">(<span name="f">f: (<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>) ⇒ <span name="scala.collection.GenTraversableOnce" class="extype">GenTraversableOnce</span>[B]</span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#fold" data-isabs="false">
      <a id="fold[A1&gt;:Term](A1)((A1, A1) ⇒ A1):A1"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">fold</span><span class="tparams">[<span name="A1">A1 &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="params">(<span name="z">z: A1</span>)</span><span class="params">(<span name="op">op: (A1, A1) ⇒ A1</span>)</span><span class="result">: A1</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#foldLeft" data-isabs="false">
      <a id="foldLeft[B](B)((B, Term) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">foldLeft</span><span class="tparams">[<span name="B">B</span>]</span><span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="op">op: (B, <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#foldRight" data-isabs="false">
      <a id="foldRight[B](B)((Term, B) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">foldRight</span><span class="tparams">[<span name="B">B</span>]</span><span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="op">op: (<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>, B) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#forall" data-isabs="false">
      <a id="forall((Term) ⇒ Boolean):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">forall</span><span class="params">(<span name="p">p: (<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#foreach" data-isabs="false">
      <a id="foreach[U]((Term) ⇒ U):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">foreach</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="f">f: (<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>) ⇒ U</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#getClass" data-isabs="false">
      <a id="getClass():java.lang.Class[_]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getClass</span><span class="params">()</span><span class="result">: java.lang.Class[_]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="prolog.interp.Prog#getElement" data-isabs="false">
      <a id="getElement():Term"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getElement</span><span class="params">()</span><span class="result">: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.interp.Prog" class="extype" href="interp/Prog.html">Prog</a> → <a name="prolog.terms.TermSource" class="extype" href="terms/TermSource.html">TermSource</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#grouped" data-isabs="false">
      <a id="grouped[B&gt;:Term](Int):GroupedIterator[B]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">grouped</span><span class="tparams">[<span name="B">B &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="params">(<span name="size">size: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.Iterator.GroupedIterator" class="extype">GroupedIterator</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#hasDefiniteSize" data-isabs="false">
      <a id="hasDefiniteSize:Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">hasDefiniteSize</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="prolog.terms.TermSource#hasNext" data-isabs="false">
      <a id="hasNext:Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">hasNext</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.terms.TermSource" class="extype" href="terms/TermSource.html">TermSource</a> → Iterator</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#hashCode" data-isabs="false">
      <a id="hashCode():Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">hashCode</span><span class="params">()</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#indexOf" data-isabs="false">
      <a id="indexOf[B&gt;:Term](B):Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">indexOf</span><span class="tparams">[<span name="B">B &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="params">(<span name="elem">elem: B</span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#indexWhere" data-isabs="false">
      <a id="indexWhere((Term) ⇒ Boolean):Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">indexWhere</span><span class="params">(<span name="p">p: (<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="pub" name="prolog.terms.TermSource#isAlive" data-isabs="false">
      <a id="isAlive:Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">var</span>
      </span>
      <span class="symbol">
        <span class="name">isAlive</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.terms.TermSource" class="extype" href="terms/TermSource.html">TermSource</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#isEmpty" data-isabs="false">
      <a id="isEmpty:Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">isEmpty</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.Any#isInstanceOf" data-isabs="false">
      <a id="isInstanceOf[T0]:Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">isInstanceOf</span><span class="tparams">[<span name="T0">T0</span>]</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li visbl="pub" name="prolog.interp.Prog#isStopped" data-isabs="false">
      <a id="isStopped:Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">var</span>
      </span>
      <span class="symbol">
        <span class="name">isStopped</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.interp.Prog" class="extype" href="interp/Prog.html">Prog</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#isTraversableAgain" data-isabs="false">
      <a id="isTraversableAgain:Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">isTraversableAgain</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="prolog.terms.TermSource#last" data-isabs="false">
      <a id="last:Term"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">var</span>
      </span>
      <span class="symbol">
        <span class="name">last</span><span class="result">: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.terms.TermSource" class="extype" href="terms/TermSource.html">TermSource</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#length" data-isabs="false">
      <a id="length:Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">length</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#map" data-isabs="false">
      <a id="map[B]((Term) ⇒ B):Iterator[B]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">map</span><span class="tparams">[<span name="B">B</span>]</span><span class="params">(<span name="f">f: (<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>) ⇒ B</span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="pub" name="prolog.terms.Term#matches" data-isabs="false">
      <a id="matches(Term,Trail):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">matches</span><span class="params">(<span name="that">that: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>, <span name="trail">trail: <a name="prolog.terms.Trail" class="extype" href="terms/Trail.html">Trail</a></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#max" data-isabs="false">
      <a id="max[B&gt;:Term](Ordering[B]):Term"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">max</span><span class="tparams">[<span name="B">B &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="params">(<span class="implicit">implicit </span><span name="cmp">cmp: Ordering[B]</span>)</span><span class="result">: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#maxBy" data-isabs="false">
      <a id="maxBy[B]((Term) ⇒ B)(Ordering[B]):Term"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">maxBy</span><span class="tparams">[<span name="B">B</span>]</span><span class="params">(<span name="f">f: (<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>) ⇒ B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="cmp">cmp: Ordering[B]</span>)</span><span class="result">: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#min" data-isabs="false">
      <a id="min[B&gt;:Term](Ordering[B]):Term"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">min</span><span class="tparams">[<span name="B">B &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="params">(<span class="implicit">implicit </span><span name="cmp">cmp: Ordering[B]</span>)</span><span class="result">: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#minBy" data-isabs="false">
      <a id="minBy[B]((Term) ⇒ B)(Ordering[B]):Term"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">minBy</span><span class="tparams">[<span name="B">B</span>]</span><span class="params">(<span name="f">f: (<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>) ⇒ B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="cmp">cmp: Ordering[B]</span>)</span><span class="result">: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#mkString" data-isabs="false">
      <a id="mkString:String"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">mkString</span><span class="result">: String</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#mkString" data-isabs="false">
      <a id="mkString(String):String"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">mkString</span><span class="params">(<span name="sep">sep: String</span>)</span><span class="result">: String</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#mkString" data-isabs="false">
      <a id="mkString(String,String,String):String"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">mkString</span><span class="params">(<span name="start">start: String</span>, <span name="sep">sep: String</span>, <span name="end">end: String</span>)</span><span class="result">: String</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="prolog.terms.SystemObject#name" data-isabs="false">
      <a id="name:String"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">name</span><span class="result">: <span name="java.lang.String" class="extype">String</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.terms.SystemObject" class="extype" href="terms/SystemObject.html">SystemObject</a> → <a name="prolog.terms.Nonvar" class="extype" href="terms/Nonvar.html">Nonvar</a></dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#ne" data-isabs="false">
      <a id="ne(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">ne</span><span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="prolog.terms.TermSource#next" data-isabs="false">
      <a id="next():Term"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">next</span><span class="params">()</span><span class="result">: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.terms.TermSource" class="extype" href="terms/TermSource.html">TermSource</a> → Iterator</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#nonEmpty" data-isabs="false">
      <a id="nonEmpty:Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">nonEmpty</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#notify" data-isabs="false">
      <a id="notify():Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">notify</span><span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#notifyAll" data-isabs="false">
      <a id="notifyAll():Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">notifyAll</span><span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="prolog.interp.Prog#orStack" data-isabs="false">
      <a id="orStack:ObjectStack[Unfolder]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">val</span>
      </span>
      <span class="symbol">
        <span class="name">orStack</span><span class="result">: <a name="prolog.terms.ObjectStack" class="extype" href="terms/ObjectStack.html">ObjectStack</a>[<a name="prolog.interp.Unfolder" class="extype" href="interp/Unfolder.html">Unfolder</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.interp.Prog" class="extype" href="interp/Prog.html">Prog</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#padTo" data-isabs="false">
      <a id="padTo[A1&gt;:Term](Int,A1):Iterator[A1]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">padTo</span><span class="tparams">[<span name="A1">A1 &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="params">(<span name="len">len: <span name="scala.Int" class="extype">Int</span></span>, <span name="elem">elem: A1</span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[A1]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="pub" name="prolog.LogicEngine#parser" data-isabs="false">
      <a id="parser:TermParser"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">val</span>
      </span>
      <span class="symbol">
        <span class="name">parser</span><span class="result">: <a name="prolog.io.TermParser" class="extype" href="io/TermParser.html">TermParser</a></span>
      </span>
      </h4>
      
    </li><li visbl="pub" name="scala.collection.Iterator#partition" data-isabs="false">
      <a id="partition((Term) ⇒ Boolean):(Iterator[Term], Iterator[Term])"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">partition</span><span class="params">(<span name="p">p: (<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: (<span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>], <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>])</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#patch" data-isabs="false">
      <a id="patch[B&gt;:Term](Int,Iterator[B],Int):Iterator[B]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">patch</span><span class="tparams">[<span name="B">B &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="params">(<span name="from">from: <span name="scala.Int" class="extype">Int</span></span>, <span name="patchElems">patchElems: <span name="scala.collection.Iterator" class="extype">Iterator</span>[B]</span>, <span name="replaced">replaced: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="pub" name="prolog.interp.Prog#popped" data-isabs="false">
      <a id="popped:Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">var</span>
      </span>
      <span class="symbol">
        <span class="name">popped</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.interp.Prog" class="extype" href="interp/Prog.html">Prog</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#product" data-isabs="false">
      <a id="product[B&gt;:Term](Numeric[B]):B"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">product</span><span class="tparams">[<span name="B">B &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="params">(<span class="implicit">implicit </span><span name="num">num: Numeric[B]</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#reduce" data-isabs="false">
      <a id="reduce[A1&gt;:Term]((A1, A1) ⇒ A1):A1"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">reduce</span><span class="tparams">[<span name="A1">A1 &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="params">(<span name="op">op: (A1, A1) ⇒ A1</span>)</span><span class="result">: A1</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#reduceLeft" data-isabs="false">
      <a id="reduceLeft[B&gt;:Term]((B, Term) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">reduceLeft</span><span class="tparams">[<span name="B">B &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="params">(<span name="op">op: (B, <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#reduceLeftOption" data-isabs="false">
      <a id="reduceLeftOption[B&gt;:Term]((B, Term) ⇒ B):Option[B]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">reduceLeftOption</span><span class="tparams">[<span name="B">B &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="params">(<span name="op">op: (B, <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>) ⇒ B</span>)</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#reduceOption" data-isabs="false">
      <a id="reduceOption[A1&gt;:Term]((A1, A1) ⇒ A1):Option[A1]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">reduceOption</span><span class="tparams">[<span name="A1">A1 &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="params">(<span name="op">op: (A1, A1) ⇒ A1</span>)</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[A1]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#reduceRight" data-isabs="false">
      <a id="reduceRight[B&gt;:Term]((Term, B) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">reduceRight</span><span class="tparams">[<span name="B">B &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="params">(<span name="op">op: (<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>, B) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#reduceRightOption" data-isabs="false">
      <a id="reduceRightOption[B&gt;:Term]((Term, B) ⇒ B):Option[B]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">reduceRightOption</span><span class="tparams">[<span name="B">B &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="params">(<span name="op">op: (<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>, B) ⇒ B</span>)</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="prolog.terms.Term#ref" data-isabs="false">
      <a id="ref:Term"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">ref</span><span class="result">: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></dd></dl></div>
    </li><li visbl="prt" name="scala.collection.TraversableOnce#reversed" data-isabs="false">
      <a id="reversed:List[Term]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">reversed</span><span class="result">: List[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[this] </dd><dt>Definition Classes</dt><dd>TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#sameElements" data-isabs="false">
      <a id="sameElements(Iterator[_]):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">sameElements</span><span class="params">(<span name="that">that: Iterator[_]</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#scanLeft" data-isabs="false">
      <a id="scanLeft[B](B)((B, Term) ⇒ B):Iterator[B]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">scanLeft</span><span class="tparams">[<span name="B">B</span>]</span><span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="op">op: (B, <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>) ⇒ B</span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#scanRight" data-isabs="false">
      <a id="scanRight[B](B)((Term, B) ⇒ B):Iterator[B]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">scanRight</span><span class="tparams">[<span name="B">B</span>]</span><span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="op">op: (<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>, B) ⇒ B</span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#seq" data-isabs="false">
      <a id="seq:Iterator[Term]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">seq</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="prolog.LogicEngine#setGoal" data-isabs="false">
      <a id="setGoal(Term,Term):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">setGoal</span><span class="params">(<span name="answer">answer: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>, <span name="goal">goal: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      
    </li><li visbl="pub" name="prolog.LogicEngine#setGoal" data-isabs="false">
      <a id="setGoal(String):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">setGoal</span><span class="params">(<span name="query">query: String</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      
    </li><li visbl="pub" name="prolog.interp.Prog#set_query" data-isabs="false">
      <a id="set_query(GOAL):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">set_query</span><span class="params">(<span name="query">query: GOAL</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.interp.Prog" class="extype" href="interp/Prog.html">Prog</a></dd></dl></div>
    </li><li visbl="pub" name="prolog.interp.Prog#set_query" data-isabs="false">
      <a id="set_query(Term,GOAL):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">set_query</span><span class="params">(<span name="answer">answer: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>, <span name="query">query: GOAL</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.interp.Prog" class="extype" href="interp/Prog.html">Prog</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#size" data-isabs="false">
      <a id="size:Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">size</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#slice" data-isabs="false">
      <a id="slice(Int,Int):Iterator[Term]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">slice</span><span class="params">(<span name="from">from: <span name="scala.Int" class="extype">Int</span></span>, <span name="until">until: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#sliding" data-isabs="false">
      <a id="sliding[B&gt;:Term](Int,Int):GroupedIterator[B]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">sliding</span><span class="tparams">[<span name="B">B &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="params">(<span name="size">size: <span name="scala.Int" class="extype">Int</span></span>, <span name="step">step: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.Iterator.GroupedIterator" class="extype">GroupedIterator</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#span" data-isabs="false">
      <a id="span((Term) ⇒ Boolean):(Iterator[Term], Iterator[Term])"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">span</span><span class="params">(<span name="p">p: (<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: (<span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>], <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>])</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="pub" name="prolog.interp.Prog#stop" data-isabs="false">
      <a id="stop():Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">stop</span><span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.interp.Prog" class="extype" href="interp/Prog.html">Prog</a> → <a name="prolog.terms.TermSource" class="extype" href="terms/TermSource.html">TermSource</a> → <a name="prolog.terms.Fluent" class="extype" href="terms/Fluent.html">Fluent</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#sum" data-isabs="false">
      <a id="sum[B&gt;:Term](Numeric[B]):B"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">sum</span><span class="tparams">[<span name="B">B &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="params">(<span class="implicit">implicit </span><span name="num">num: Numeric[B]</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#synchronized" data-isabs="false">
      <a id="synchronized[T0](⇒ T0):T0"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">synchronized</span><span class="tparams">[<span name="T0">T0</span>]</span><span class="params">(<span name="arg0">arg0: ⇒ T0</span>)</span><span class="result">: T0</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#take" data-isabs="false">
      <a id="take(Int):Iterator[Term]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">take</span><span class="params">(<span name="n">n: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#takeWhile" data-isabs="false">
      <a id="takeWhile((Term) ⇒ Boolean):Iterator[Term]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">takeWhile</span><span class="params">(<span name="p">p: (<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="pub" name="prolog.terms.TermSource#taken" data-isabs="false">
      <a id="taken:Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">var</span>
      </span>
      <span class="symbol">
        <span class="name">taken</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.terms.TermSource" class="extype" href="terms/TermSource.html">TermSource</a></dd></dl></div>
    </li><li visbl="pub" name="prolog.terms.Term#tcopy" data-isabs="false">
      <a id="tcopy(Copier):Term"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">tcopy</span><span class="params">(<span name="dict">dict: <a name="prolog.terms.Copier" class="extype" href="terms/Copier.html">Copier</a></span>)</span><span class="result">: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#toArray" data-isabs="false">
      <a id="toArray[B&gt;:Term](ClassManifest[B]):Array[B]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toArray</span><span class="tparams">[<span name="B">B &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: ClassManifest[B]</span>)</span><span class="result">: <span name="scala.Array" class="extype">Array</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#toBuffer" data-isabs="false">
      <a id="toBuffer[B&gt;:Term]:Buffer[B]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toBuffer</span><span class="tparams">[<span name="B">B &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="result">: <span name="scala.collection.mutable.Buffer" class="extype">Buffer</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#toIndexedSeq" data-isabs="false">
      <a id="toIndexedSeq[B&gt;:Term]:IndexedSeq[B]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toIndexedSeq</span><span class="tparams">[<span name="B">B &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="result">: <span name="scala.collection.immutable.IndexedSeq" class="extype">IndexedSeq</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#toIterable" data-isabs="false">
      <a id="toIterable:Iterable[Term]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toIterable</span><span class="result">: <span name="scala.collection.Iterable" class="extype">Iterable</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#toIterator" data-isabs="false">
      <a id="toIterator:Iterator[Term]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toIterator</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="prolog.terms.TermSource#toList" data-isabs="false">
      <a id="toList(Boolean):Term"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toList</span><span class="params">(<span name="toCopy">toCopy: <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.terms.TermSource" class="extype" href="terms/TermSource.html">TermSource</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#toList" data-isabs="false">
      <a id="toList:List[Term]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toList</span><span class="result">: List[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#toMap" data-isabs="false">
      <a id="toMap[T, U](&lt;:&lt;[Term, (T, U)]):Map[T, U]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toMap</span><span class="tparams">[<span name="T">T</span>, <span name="U">U</span>]</span><span class="params">(<span class="implicit">implicit </span><span name="ev">ev: <span name="scala.Predef.&lt;:&lt;" class="extype">&lt;:&lt;</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>, (T, U)]</span>)</span><span class="result">: <span name="scala.collection.immutable.Map" class="extype">Map</span>[T, U]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#toSeq" data-isabs="false">
      <a id="toSeq:Seq[Term]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toSeq</span><span class="result">: <span name="scala.collection.Seq" class="extype">Seq</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#toSet" data-isabs="false">
      <a id="toSet[B&gt;:Term]:Set[B]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toSet</span><span class="tparams">[<span name="B">B &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="result">: <span name="scala.collection.immutable.Set" class="extype">Set</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="prolog.terms.TermSource#toSink" data-isabs="false">
      <a id="toSink(TermSink):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toSink</span><span class="params">(<span name="to">to: <a name="prolog.terms.TermSink" class="extype" href="terms/TermSink.html">TermSink</a></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.terms.TermSource" class="extype" href="terms/TermSource.html">TermSource</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#toStream" data-isabs="false">
      <a id="toStream:Stream[Term]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toStream</span><span class="result">: <span name="scala.collection.immutable.Stream" class="extype">Stream</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#toString" data-isabs="false">
      <a id="toString():String"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toString</span><span class="params">()</span><span class="result">: <span name="java.lang.String" class="extype">String</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator → AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#toTraversable" data-isabs="false">
      <a id="toTraversable:Traversable[Term]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toTraversable</span><span class="result">: <span name="scala.collection.Traversable" class="extype">Traversable</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="prolog.interp.Prog#trail" data-isabs="false">
      <a id="trail:Trail"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">val</span>
      </span>
      <span class="symbol">
        <span class="name">trail</span><span class="result">: <a name="prolog.terms.Trail" class="extype" href="terms/Trail.html">Trail</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.interp.Prog" class="extype" href="interp/Prog.html">Prog</a></dd></dl></div>
    </li><li visbl="pub" name="prolog.terms.Nonvar#unify" data-isabs="false">
      <a id="unify(Term,Trail):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">unify</span><span class="params">(<span name="other">other: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>, <span name="trail">trail: <a name="prolog.terms.Trail" class="extype" href="terms/Trail.html">Trail</a></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.terms.Nonvar" class="extype" href="terms/Nonvar.html">Nonvar</a> → <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></dd></dl></div>
    </li><li visbl="pub" name="prolog.terms.Term#var_array_of" data-isabs="false">
      <a id="var_array_of:Array[Term]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">var_array_of</span><span class="result">: <span name="scala.Array" class="extype">Array</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></dd></dl></div>
    </li><li visbl="pub" name="prolog.terms.Term#vars_of" data-isabs="false">
      <a id="vars_of:Term"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">vars_of</span><span class="result">: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></dd></dl></div>
    </li><li visbl="pub" name="prolog.terms.Term#vcollect" data-isabs="false">
      <a id="vcollect(LinkedHashSet[Term]):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">vcollect</span><span class="params">(<span name="dict">dict: <span name="scala.collection.mutable.LinkedHashSet" class="extype">LinkedHashSet</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>]</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#wait" data-isabs="false">
      <a id="wait():Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">wait</span><span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#wait" data-isabs="false">
      <a id="wait(Long,Int):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">wait</span><span class="params">(<span name="arg0">arg0: <span name="scala.Long" class="extype">Long</span></span>, <span name="arg1">arg1: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#wait" data-isabs="false">
      <a id="wait(Long):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">wait</span><span class="params">(<span name="arg0">arg0: <span name="scala.Long" class="extype">Long</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#withFilter" data-isabs="false">
      <a id="withFilter((Term) ⇒ Boolean):Iterator[Term]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">withFilter</span><span class="params">(<span name="p">p: (<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#zip" data-isabs="false">
      <a id="zip[B](Iterator[B]):Iterator[(Term, B)]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">zip</span><span class="tparams">[<span name="B">B</span>]</span><span class="params">(<span name="that">that: <span name="scala.collection.Iterator" class="extype">Iterator</span>[B]</span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[(<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>, B)]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#zipAll" data-isabs="false">
      <a id="zipAll[B, A1&gt;:Term, B1&gt;:B](Iterator[B],A1,B1):Iterator[(A1, B1)]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">zipAll</span><span class="tparams">[<span name="B">B</span>, <span name="A1">A1 &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>, <span name="B1">B1 &gt;: B</span>]</span><span class="params">(<span name="that">that: <span name="scala.collection.Iterator" class="extype">Iterator</span>[B]</span>, <span name="thisElem">thisElem: A1</span>, <span name="thatElem">thatElem: B1</span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[(A1, B1)]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#zipWithIndex" data-isabs="false">
      <a id="zipWithIndex:Iterator[(Term, Int)] { ... /* 2 definitions in type refinement */ }"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">zipWithIndex</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[(<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>, <span name="scala.Int" class="extype">Int</span>)] { ... /* 2 definitions in type refinement */ }</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd></dl></div>
    </li></ol>
            </div>

        <div class="values members" id="values">
              <h3>Deprecated Value Members</h3>
              <ol><li visbl="pub" name="scala.collection.Iterator#append" data-isabs="false">
      <a id="append[B&gt;:Term](Iterator[B]):Iterator[B]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name deprecated" title="Deprecated: (Since version 2.3.2) use ++">append</span><span class="tparams">[<span name="B">B &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="params">(<span name="that">that: <span name="scala.collection.Iterator" class="extype">Iterator</span>[B]</span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p><i>(Since version 2.3.2)</i> use <code>++</code></p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#counted" data-isabs="false">
      <a id="counted:CountedIterator[Term]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name deprecated" title="Deprecated: (Since version 2.8.0) use zipWithIndex in Iterator">counted</span><span class="result">: <span name="scala.CountedIterator" class="extype">CountedIterator</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p><i>(Since version 2.8.0)</i> use zipWithIndex in Iterator</p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#findIndexOf" data-isabs="false">
      <a id="findIndexOf((Term) ⇒ Boolean):Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name deprecated" title="Deprecated: (Since version 2.8.0) use indexWhere instead">findIndexOf</span><span class="params">(<span name="p">p: (<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p><i>(Since version 2.8.0)</i> use <code>indexWhere</code> instead</p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#readInto" data-isabs="false">
      <a id="readInto[B&gt;:Term](Array[B]):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name deprecated" title="Deprecated: (Since version 2.8.0) use copyToArray instead">readInto</span><span class="tparams">[<span name="B">B &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="params">(<span name="xs">xs: <span name="scala.Array" class="extype">Array</span>[B]</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p><i>(Since version 2.8.0)</i> use copyToArray instead</p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#readInto" data-isabs="false">
      <a id="readInto[B&gt;:Term](Array[B],Int):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name deprecated" title="Deprecated: (Since version 2.8.0) use copyToArray instead">readInto</span><span class="tparams">[<span name="B">B &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="params">(<span name="xs">xs: <span name="scala.Array" class="extype">Array</span>[B]</span>, <span name="start">start: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p><i>(Since version 2.8.0)</i> use copyToArray instead</p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Iterator#readInto" data-isabs="false">
      <a id="readInto[B&gt;:Term](Array[B],Int,Int):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name deprecated" title="Deprecated: (Since version 2.8.0) use copyToArray instead">readInto</span><span class="tparams">[<span name="B">B &gt;: <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></span>]</span><span class="params">(<span name="xs">xs: <span name="scala.Array" class="extype">Array</span>[B]</span>, <span name="start">start: <span name="scala.Int" class="extype">Int</span></span>, <span name="sz">sz: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterator</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p><i>(Since version 2.8.0)</i> use copyToArray instead</p></dd></dl></div>
    </li></ol>
            </div>
        </div>

        <div id="inheritedMembers">
        <div name="prolog.interp.Prog" class="parent">
              <h3>Inherited from <a name="prolog.interp.Prog" class="extype" href="interp/Prog.html">Prog</a></h3>
            </div><div name="prolog.terms.TermSource" class="parent">
              <h3>Inherited from <a name="prolog.terms.TermSource" class="extype" href="terms/TermSource.html">TermSource</a></h3>
            </div><div name="scala.collection.Iterator" class="parent">
              <h3>Inherited from <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>]</h3>
            </div><div name="scala.collection.TraversableOnce" class="parent">
              <h3>Inherited from <span name="scala.collection.TraversableOnce" class="extype">TraversableOnce</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>]</h3>
            </div><div name="scala.collection.GenTraversableOnce" class="parent">
              <h3>Inherited from <span name="scala.collection.GenTraversableOnce" class="extype">GenTraversableOnce</span>[<a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a>]</h3>
            </div><div name="prolog.terms.Fluent" class="parent">
              <h3>Inherited from <a name="prolog.terms.Fluent" class="extype" href="terms/Fluent.html">Fluent</a></h3>
            </div><div name="prolog.terms.SystemObject" class="parent">
              <h3>Inherited from <a name="prolog.terms.SystemObject" class="extype" href="terms/SystemObject.html">SystemObject</a></h3>
            </div><div name="prolog.terms.Nonvar" class="parent">
              <h3>Inherited from <a name="prolog.terms.Nonvar" class="extype" href="terms/Nonvar.html">Nonvar</a></h3>
            </div><div name="prolog.terms.Term" class="parent">
              <h3>Inherited from <a name="prolog.terms.Term" class="extype" href="terms/Term.html">Term</a></h3>
            </div><div name="java.lang.Cloneable" class="parent">
              <h3>Inherited from <span name="java.lang.Cloneable" class="extype">Cloneable</span></h3>
            </div><div name="scala.AnyRef" class="parent">
              <h3>Inherited from AnyRef</h3>
            </div><div name="scala.Any" class="parent">
              <h3>Inherited from <span name="scala.Any" class="extype">Any</span></h3>
            </div>
        </div>

      </div>

      <div id="tooltip"></div>

      <div id="footer">  </div>


    </body>
      </html>